package com.hsjk.szwj.module.train.api;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.hsjk.szwj.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.hsjk.szwj.module.train.api.dto.CheckoutOrderDTO;
import com.hsjk.szwj.module.train.api.dto.UpdateCheckoutOrderDTO;
import com.hsjk.szwj.module.train.convert.CheckoutOrderConvert;
import com.hsjk.szwj.module.train.dal.dataobject.order.CheckoutOrderDO;
import com.hsjk.szwj.module.train.dal.mysql.order.ICheckoutOrderMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author chenjiawei
 * @desc
 * @Date 2023/09/05 09:42
 **/
@Service
@Slf4j
public class CheckoutOrderApiImpl implements ICheckoutOrderApi {
    @Resource
    private ICheckoutOrderMapper checkoutOrderMapper;

    @Override
    public int createCheckoutOrder(CheckoutOrderDTO dto) {
        CheckoutOrderDO checkoutOrderDO = CheckoutOrderConvert.INSTANCE.convertCheckoutOrderDO(dto);
        return checkoutOrderMapper.insert(checkoutOrderDO);
    }

    @Override
    public int batchCreateCheckoutOrder(List<CheckoutOrderDTO> dtos) {
        List<CheckoutOrderDO> checkoutOrderDOS = CheckoutOrderConvert.INSTANCE.convertCheckoutOrderDOList(dtos);
        checkoutOrderMapper.insertBatch(checkoutOrderDOS);
        return 1;
    }

    @Override
    public List<CheckoutOrderDTO> getCheckoutOrderListById(Long orderId, String checkoutPath) {
        List<CheckoutOrderDO> checkoutOrderDOS = checkoutOrderMapper.selectList(new LambdaQueryWrapper<CheckoutOrderDO>()
                .eq(CheckoutOrderDO::getTrainOrderId, orderId)
                .eq(CheckoutOrderDO::getCheckoutPath, checkoutPath));
        return CheckoutOrderConvert.INSTANCE.convertCheckoutOrderDTOList(checkoutOrderDOS);
    }

    @Override
    public CheckoutOrderDTO getCheckoutOrderByDivisionReceiverId(Long divisionReceiverId, Long orderNo) {
        CheckoutOrderDO checkoutOrderDO = checkoutOrderMapper.selectOne(new LambdaQueryWrapperX<CheckoutOrderDO>()
                .eq(CheckoutOrderDO::getDivisionReceiverId, divisionReceiverId)
                .eq(CheckoutOrderDO::getTrainOrderId, orderNo));
        return CheckoutOrderConvert.INSTANCE.convertCheckoutOrderDTO(checkoutOrderDO);
    }

    @Override
    public int updateCheckoutOrderStatusById(UpdateCheckoutOrderDTO updateCheckoutOrderDTO) {
        CheckoutOrderDO checkoutOrderDO = new CheckoutOrderDO();
        checkoutOrderDO.setId(updateCheckoutOrderDTO.getId());
        checkoutOrderDO.setStatus(updateCheckoutOrderDTO.getStatus());
        return checkoutOrderMapper.updateById(checkoutOrderDO);
    }

    @Override
    public Boolean checkIfRepeat(CheckoutOrderDTO checkoutOrderDTO) {
        log.info("checkIfRepeat-{}", checkoutOrderDTO);
        boolean ck = false;
        CheckoutOrderDO checkoutOrderDO = checkoutOrderMapper.selectOne(new LambdaQueryWrapperX<CheckoutOrderDO>()
                .eq(CheckoutOrderDO::getMemberId, checkoutOrderDTO.getMemberId())
                .eq(CheckoutOrderDO::getTrainOrderId, checkoutOrderDTO.getTrainOrderId())
                .eq(CheckoutOrderDO::getCheckoutType, checkoutOrderDTO.getCheckoutType())
                .eq(CheckoutOrderDO::getCheckoutPath, checkoutOrderDTO.getCheckoutPath())
                .eq(CheckoutOrderDO::getCheckoutAccount, checkoutOrderDTO.getCheckoutAccount()));
        if (ObjectUtil.isNotNull(checkoutOrderDO)) {
            ck = true;
        }
        return ck;
    }
}
